Bellman-ford 算法详解

昨天说的dijkstra固然很好用，但是却解决不了负权边，想要解决这个问题，就要用到Bellman-ford.

我个人认为Bellman-Ford比dijkstra要好理解一些，还是先上数据（有向图）：

5 71 2 81 3 52 3 -6
5 4 -32 4 73 5 -24 5 -3

在讲述开，先设几个数组：

origin[i]表示编号为i这条边的起点编号，如origin[4]=2

destination[i]表示编号为i这条边的终点编号，如origin[5]=5

value[i]表示编号为i这条边的权值，如value[3]=-6

dis[i]，和昨天一样，源点到i号点的估计距离，经过不断更新会变成时机距离，就是答案。

bellmanford的实际意义就是扫描一条边，看如果走这条边能不能使这条边的dis[destination[i]],变少，现在我来模拟一下：

初始的dis：[0,∞,∞,∞,∞]

首先从第一条边1 2 8开始，判断走这条边能不能使这条边的终点的dis变短，原本dis[2]=∞，而dis[1]=0,而这条边的权值：value[1]=8，0+8<∞所以将dis[2]更新成8.

dis[0,8,∞,∞,∞]

然后是第二条边，用刚才的方法将dis[3]从∞更新成5.

dis[0,8,5,∞,∞]

第三条2 3 -8，原本的dis[3]=5,如果走第三条边，则dis[3]=dis[2]+value[3]=8+(-6)=2<5,所以dis[3]更新成2.

dis[0,8,2,∞,∞]

以此类推，经过第一轮更新，dis数组如下：

dis[0,8,2,15,0]

但是第一次更新后，并不是最优解于是开始第二次更新。

按照第一次更新的步骤一步一步来得到的答案是

dis[0,8,2,-3,0]

这便是最优解，但是问题来了，一般要更新多少次呢？

n-1次。这样能保证更新出的一定是最优解。

好了，呈上代码：

#include <iostream>#include <algorithm>#include <cmath>#include <cstdio>#include <cstring>#include <cstdlib>using namespace std;int dis[10010];int origin[10010],destination[10010],value[10010];//刚刚说过的三个数组int n,m;void Bellman_ford(int a){    memset(dis,88,sizeof(dis));//赋初始值    dis[a]=0;    for(int i=1;i<=n-1;i++)//更新n-1次        for(int j=1;j<=m;j++)//更新每一条边            dis[destination[j]]=min(dis[destination[j]],dis[origin[j]]+value[j]);//判断是否更新 } int main(){    cin>>n>>m;    for(int i=1;i<=m;i++)        cin>>origin[i]>>destination[i]>>value[i];    Bellman_ford(1);    for(int i=1;i<=n;i++)        cout<<dis[i]<<" "; }

 有些人可能发现了，很多时候实际上不用更新n-1次，因此我们可以用队列优化：

每次选出队首点，对与队首点链接的所有点的dis进行更新，并加入队列，然后队首点pop出队列，

这个算法最好用邻接表实现，代码如下：

#include <iostream>#include <algorithm>#include <cmath>#include <cstdio>#include <cstring>#include <cstdlib>#include <queue>using namespace std;int dis[10010];int book[10010];int origin[10010],destination[10010],value[10010];int n,m;int total;int next[10010],head[10010];void adl(int a,int b,int c)//邻接表{   total++;   origin[total]=a;   destination[total]=b;   value[total]=c;   next[total]=head[a];   head[a]=total;}void Bellman_ford(int a){    memset(book,0,sizeof(book));//book[i]表示i号点是否在队列里    memset(dis,88,sizeof(dis));    queue <int> q;    q.push(a);    book[a]=1;    dis[a]=0;    while(!q.empty())//当队列不为空时更新    {        for(int e=head[q.front()];e;e=next[e])//枚举队首点相邻的每一个点        {            if(dis[destination[e]]>dis[origin[e]]+value[e])            {                dis[destination[e]]=dis[origin[e]]+value[e];                if(book[destination[e]]==0)                {                    q.push(destination[e]);//将更新的这一个点入队                    book[destination[e]]=1;                }            }        }        q.pop();//弹出队首元素    } } int main(){    cin>>n>>m;    for(int i=1;i<=m;i++)    {        int a,b,c;        cin>>a>>b>>c;        adl(a,b,c);   }     Bellman_ford(1);    for(int i=1;i<=n;i++)        cout<<dis[i]<<" "; }

总结一下，bellman_ford的空间复杂度是m时间复杂度是O（nm），经过队列优化，时间复杂度是<=O（nm）。