图的单源最短路径Bellman-Ford算法

Dijkstra算法是处理单源最短路径的有效算法，但它局限于边的权值非负的情况，若图中出现权值为负的边，Dijkstra算法就会失效，求出的最短路径就可能是错的。原因在于Dijkstra算法在利用顶点u的dist[]值去递推T集合个顶点的dist[k]值时，前提是顶点u的dist[]值是当前T集合中最短路径长度最小的，如果图中所有的边权值都是正的，这样推导是没有问题的，但是如果有负权值的边，那么边的权值和会减小，就不是当前最小的边，所以这样是不正确的。

适用条件&范围：

单源最短路径(从源点s到其它所有顶点v);

有向图&无向图(无向图可以看作(u,v),(v,u)同属于边集E的有向图);

边权可正可负(不能是负权回路);

差分约束系统;

Bellman-Ford算法的流程如下：
给定图G(V, E)（其中V、E分别为图G的顶点集与边集），源点s，数组dist[i]记录从源点s到顶点i的路径长度.

以下操作循环执行至多n-1次，n为顶点数：

Bellman-Ford算法构造了一个最短路径长度数组序列：dist[u](1),dist[u](2),dist[u](3),dist[u](4),dist[u](5),dist[u](6)...........dist[u](n-1).

dist[u](1)为从源点v0到终点u的只经过一条边的最短路径长度，并有dist[u](1)=map[v0][u];

dist[u](2)为从源点v0出发最多经过不构成负权回路的二条边到达终点u的最短路径长度。

dist[u](3)为从源点v0出发最多经过不构成负权回路的三条边到达终点u的最短路径长度。

。。。。。

dist[u](n-1)为从源点v0出发最多经过不构成负权回路的n-1条边到达终点u的最短路径长度。

递推公式：

dist[u](k)=min( dist[u](k-1), min（dist[j](k-1)+map[j][u]）).

对于每一条边e(u, v)，如果dist[u] + w(u, v) < dist[v]，则另dist[v] = dist[u]+w(u, v)。w(u, v)为边e(u,v)的权值；
若上述操作没有对dist进行更新，说明最短路径已经查找完毕，或者部分点不可达，跳出循环。否则执行下次循环；

为了检测图中是否存在负环路，即权值之和小于0的环路。对于每一条边e(u, v)，如果存在distt[u] + w(u, v) < dist[v]的边，则图中存在负环路，即是说改图无法求出单源最短路径。否则数组dist[n]中记录的就是源点s到各顶点的最短路径长度。

可知，Bellman-Ford算法寻找单源最短路径的时间复杂度为O(V*E).

Bellman－Ford算法步骤
第一，初始化所有点。每一个点保存一个值，表示从原点到达这个点的距离，将原点的值设为0，其它的点的值设为无穷大（表示不可达）。
第二，进行循环，循环下标为从1到n－1（n等于图中点的个数）。在循环内部，遍历所有的边，进行松弛计算。
第三，遍历途中所有的边判断是否存在这样情况：
d（v） > d (u) + w(u,v)  是则更新路径信息。

 

附加：负权回路判断

n-1次循环结束再次执行第三步，如果存在这样的情况，则说明存在负权回路。

以hdu 1874为例

46MS

#include <iostream>
using namespace std;
const int MAX=1000;
const int INF=100000000;
int path[MAX];
int dist[MAX];
int map[MAX][MAX];
int n;
bool Bellman(int u0)
{
    for (int i=0; i<n; i++)   //初始化
    {
        dist[i]=INF;
    }
    dist[u0]=0;
    for (int k=1; k<n; k++)  //n-1次循环
    {
        for (int u=0; u<n; u++)  //遍历每条边
        {
            if(u!=u0)
            {
                for (int v=0; v<n; v++)
                {
                    if(map[v][u]<INF && dist[v]+map[v][u]<dist[u])  
                    {
                        dist[u]=dist[v]+map[v][u];   //更新
                        path[u]=v;
                    }
                }
            }
        }
    }
    for (int v=0; v<n; v++)  //检查是否存在负权回路
    {
        for (int u=0; u<n; u++)
        {
            
            if(map[v][u]<INF && dist[v]+map[v][u]<dist[u])
            {
                return false;
            }
        }
    }
    return true;
}
void ShowPath(int v0,int v)  //路径显示
{
    int num[MAX];
    int pos=0;
    num[pos++]=v;
    int k=path[v];
    while (k!=v0)
    {
        num[pos++]=k;
        k=path[k];
    }
    num[pos++]=v0;
    for (int i=pos-1; i>=0; i--)
    {
        printf("%d ",num[i]);
    }
    printf("\n");
}
int main()
{
    int u,v,w,m;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        for (int i=0; i<n; i++)
        {
            for (int j=0; j<n; j++)
            {
                if(i==j)
                {
                    map[i][j]=0;
                }
                else
                {
                    map[i][j]=INF;
                }
            }
        }
        while (m--)
        {
            scanf("%d%d%d",&u,&v,&w);
            if(w<map[u][v])  //判重边
            {
                map[u][v]=w;
                map[v][u]=w;
            }
        }
        int s,t;
        scanf("%d%d",&s,&t);
        if(Bellman(s)&&dist[t]!=INF)
        {
            printf("\n");
            for (int i=1; i<n; i++)
           {
                printf("路径长度（0--%d）：%d path:",i,dist[i]);
                ShowPath(s, i);
            }
            printf("%d\n",dist[t]);
        }
        else
        {
            printf("-1\n");
        }

    }
    return 0;
}

采用邻接矩阵算法的时间复杂度是O(n3),采用边集数组时间复杂度可降为O(n2),实现如下：

0MS

#include <iostream>
using namespace std;
const int MAX=2020;
const int INF=100000000;
int path[MAX];
int dist[MAX];
int n,cnt;
struct node
{
    int u,v,w;
}Edges[MAX];
bool Bellman(int u0)
{
    for (int i=0; i<n; i++)   //初始化
    {
        dist[i]=INF;
        path[i]=u0;
    }
    dist[u0]=0;
    for (int k=1; k<n; k++)  //n-1次循环
    {
        for (int i=0; i<cnt; i++)
        {
            if(dist[Edges[i].u]!=EOF && dist[Edges[i].v]>dist[Edges[i].u]+Edges[i].w)
            {
                dist[Edges[i].v]=dist[Edges[i].u]+Edges[i].w;
                path[Edges[i].v]=Edges[i].u;
            }
        }
    }
    for (int i=0; i<cnt; i++)
    {
        if(dist[Edges[i].v]>dist[Edges[i].u]+Edges[i].w)
        {
            return false;
        }
    }
    return true;
}
void ShowPath(int v0,int v)  //路径显示
{
    int num[MAX];
    int pos=0;
    num[pos++]=v;
    int k=path[v];
    while (k!=v0)
    {
        num[pos++]=k;
        k=path[k];
    }
    num[pos++]=v0;
    for (int i=pos-1; i>=0; i--)
    {
        printf("%d ",num[i]);
    }
    printf("\n");
}
int main()
{
    int m,u,v,w;
    while (scanf("%d%d",&n,&m)!=EOF)
    {
        cnt=0;
        while (m--)
        {
            scanf("%d%d%d",&u,&v,&w);
            Edges[cnt].u=u;
            Edges[cnt].v=v;
            Edges[cnt++].w=w;
            
            Edges[cnt].u=v;   //这里注意  双向道路
            Edges[cnt].v=u;
            Edges[cnt++].w=w;
        }
        int s,t;
        scanf("%d%d",&s,&t);
        Bellman(s);
        if(dist[t]==INF)
        {
            printf("-1\n");
            for (int i=1; i<n; i++)
            {
                printf("路径长度（0--%d）：%d path:",i,dist[i]);
                ShowPath(0, i);
            }
        }
        else
        {
            printf("%d\n",dist[t]);
        }
    }
    return 0;
}