最短路 Bellman-Ford(贝尔曼-福特)

Bellman-Ford(边权可正可负)

Bellman-Ford算法的迭代松弛操作,实际上就是按顶点距离s的层次,逐层生成这棵最短路径树的过程。

在对每条边进行1遍松弛的时候,生成了从s出发,层次至多为1的那些树枝。也就是说,找到了与s至多有1条边相联的那些顶点的最短路径;对每条边进行第2遍松弛的时候,生成了第2层次的树枝,就是说找到了经过2条边相连的那些顶点的最短路径……。因为最短路径最多只包含n-1 条边,所以,只需要循环n-1 次。

如果最短路存在,则一定不含环:

1.存在零环或正环,则去掉环路径不会变长

2.存在负环,则只要绕着环走,路径只会越来越短,下界不收敛,不存在最短路


最短路只包含n-1个结点(不包含起点)

操作步骤:

第一,初始化所有点。每一个点保存一个值,表示从原点到达这个点的距离,将原点的值设为0,其它的点的值设为无穷大(表示不可达)。


第二,进行循环,循环下标为从1到n-1(n等于图中点的个数)。在循环内部,遍历所有的边,进行松弛计算。


第三,遍历途中所有的边(edge(u,v)),判断是否存在这样情况:
d(v) > d (u) + w(u,v)说明无法向下收敛



#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
#define inf 0x7ffffff

struct Edge
{
    int u,v,cost;
}edge[2000];

int pre[200];//父亲

int dis[200];//到源点的距离

int n,m,src;//点的个数,边数,源点

bool relax(int u,int v,int cost)//对边进行松弛
{
    if(dis[v]>dis[u]+cost)
    {
        dis[v]=dis[u]+cost;
        return true;//成功松弛
    }
    return false;//没有松弛成功
}

int Bellman_Ford()
{
    int i,j,flag;
    for(i=1;i<=n;i++) dis[i]=(i==src? 0:inf);//第一步:初始化dis
    for(i=1;i<n;i++)//第二步:进行 n-1次迭代,每次对所有边进行松弛
    {
        flag=0;
        for(j=0;j<m;j++)
        {
            if(relax(edge[j].u,edge[j].v,edge[j].cost))
            {
                pre[v]=u;//记录路径
                flag=1;
            }
        }
        if(!flag) break;//所有的边都没有松弛成功
    }
    for(i=0;i<m;i++)//第三步:如果能够继续松弛,说明下界不收敛,存在负环
    {
        if(relax(edge[i].u,edge[i].v,edge[i].cost))
        {
            return 0;
        }
    }
    return 1;
}

int main()
{
    int i,j;
    while(~scanf("%d%d%d",&n,&m,&src))
    {
        for(i=0;i<m;i++)
        {
            scanf("%d%d%d",&edge[i].u,&edge[i].v,&edge[i].cost);//输入每条边的 左右端点,权值
        }
        if(Bellman_Ford())
        {
            for(i=1;i<=n;i++)
            {
                printf("%d\n",dis[i]); //输出各个点到源点的距离
            }
        }
        else printf("have negative circle\n");

    }
    return 0;
}
输入案例1.
4 6 1
1 2 20
1 3 5
4 1 -200
2 4 4
4 2 4
3 4 2



输入案例2.
4 6 1
1 2 2
1 3 5
4 1 10
2 4 4
4 2 4
3 4 2

你可能感兴趣的:(最短路 Bellman-Ford(贝尔曼-福特))