Bellman-ford 算法详解

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

我个人认为Bellman-Ford比dijkstra要好理解一些,还是先上数据(有向图):

5 7
1 2 8
1 3 5
2 3 -6
5 4 -3 2 4 7 3 5 -2 4 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)。

 

posted @ 2017-07-23 15:37  Dijkstra·Liu  阅读(13332)  评论(1编辑  收藏  举报