Bellman-Ford模板

Bellman-Ford算法流程分为三个阶段:

(1)    初始化:将除源点外的所有顶点的最短距离估计值 d[v] ←+∞, d[s] ←0;

(2)    迭代求解:反复对边集E中的每条边进行松弛操作,使得顶点集V中的每个顶点v的最短距离估计值逐步逼近其最短距离;(运行|v|-1次)

(3)    检验负权回路:判断边集E中的每一条边的两个端点是否收敛。如果存在未收敛的顶点,则算法返回false,表明问题无解;否则算法返回true,并且从源点可达的顶点v的最短距离保存在 d[v]中。

算法描述如下:

Bellman-Ford(G,w,s) boolean   //G ,边集 函数 w s为源点

1        for each vertex v ∈ V(G) do        //初始化 1阶段

2            d[v] ←+∞

3        d[s] ←0;                             //1阶段结束

4        for i=1 to |v|-1 do               //2阶段开始,双重循环。

5           for each edge(u,v) ∈E(G) do //边集数组要用到,穷举每条边。

6              If d[v]> d[u]+ w(u,v) then      //松弛判断

7                 d[v]=d[u]+w(u,v)               //松弛操作   2阶段结束

8        for each edge(u,v) ∈E(G) do

9            If d[v]> d[u]+ w(u,v) then

10            Exit false

11    Exit true

算法模板(C++)

typedef struct edge
{
   int v;//起点
   int u;//终点
   int w;
}edge;
edge edges[200004];
int d[1004];
int maxData = 1000000000;       //此处要特别注意,bellman-ford算法中不要使用0x7fffffff,为此wa了n次
int edgenum;
bool BellmanFord(int s)
{
    int i,j;
    bool flag = false;
    for(i=1;i<n+1;++i)
    {
        d[i] = maxData;  //其余点的距离设置为无穷
    }
    d[s]=0;    //源点的距离设置为0
    for(i=1;i<n;++i)
    {
        flag = false;              //优化:如果某次迭代中没有任何一个d值改变,尽可以立刻退出迭代而不需要把所有的n-1次迭代都做完
        for(j=0;j<edgenum;++j)
        {
            if(d[edges[j].u]>d[edges[j].v]+edges[j].w)
            {
                flag =true;
                d[edges[j].u]=d[edges[j].v]+edges[j].w;
            }
        }
        if(!flag)
           break;
    }
    for(i=0;i<edgenum;++i)
    {
        if(d[edges[i].v]<maxData && d[edges[i].u]>d[edges[i].v]+edges[i].w)
        {
             return false;
        }
    }
    return true;

}

主函数中: 
edgenum=0;
for(i=0;i<m;++i)
{
       cin>>start>>end>>w;
       edges[edgenum].v = start;
       edges[edgenum].u = end;
       edges[edgenum].w = w;
       edgenum++;
}  

 

 

你可能感兴趣的:(for)