bellman_ford

bellman_ford（贝尔曼-福特）算法 ：因为dijkstra算法不能处理带负权边的图，这时候就可以利用bellman_ford算法。（ 设想从我们可以从图中找到一个环路（即从v出发，经过若干个点之后又回到v）且这个环路中所有路径的权值之和为负。那么通过这个环路，环路中任意两点的最 短路径就可以无穷小下去。如果不处理这个负环路，程序就会永远运行下去。 而Bellman-Ford算法具有分辨这种负环路的能力 ）

 

时间复杂度 ：O（ne）——n是点数，e是边数。如果是邻接阵的话应该就是O（n^3）.

联系 ：可以优化成SPFA。可以用来写差分约束

 

实现过程 ：设G为加权有向图 V是所有结点的集合 E是所有路径的集合 S表示源点 n表示V中所有结点的数目 weight(u,v)表示从结点u  到结点v的路径的权值。 Distanz（v）表示从源点s出发到结点v的最短路径的距离，（或者说是从s到v所有的路径中权值的最小值）。Predecessor(v)表示节点 v的父结点

在Bellman-Ford算法结束之后，可以输出，G是不是包含一个负环路。如果G不包含负环路，那么Distanz就存储了从s出发到所有结点的距离。

Bellman-Ford算法的伪代码如下：
========================================
01 for 每一个结点v 属于 V
02 Distanz(v) := 无穷大， Predecessor(v) := null
03 Distanz(s) := 0，Predecessor(s):= null;

04 循环 n-1 次
05     for 每一条路径 （u,v）属于 E
06         if Distanz(u) + weight(u,v) < Distanz(v)
07         then
08            Distanz(v) := Distanz(u) + weight(u,v)
09            Predecessor(v) := u;

10 for 每一条路径 （u，v）属于 E
11     if Distanz(u) + weight(u,v) < Distanz(v)
12     then
13       中止程序并且返回 “找到负循环”
14 返回
==============================================

 

下面是我用bellman_ford 和静态邻接表写的hdu2544 ：

#include <iostream> using namespace std; const long point_maxn = 105; const long edge_maxn = 10005; const long lmaxn = 1000000000; int n; int m; struct node { int v; int w; int next; }edge[edge_maxn]; int pre[point_maxn]; int dirs[point_maxn]; void Init() { int i,j; int a,b,c; int Index = 1; memset(pre,-1,sizeof(pre)); for(i=0;i<m;i++) { int flag; scanf("%d%d%d",&a,&b,&c); for(flag=0,j=pre[a];j!=-1;j=edge[j].next) { if(edge[j].v == b) { if(edge[j].w > c) { edge[j].w = c; } flag = 1; break; } } if(flag == 1) continue; edge[Index].v = b; edge[Index].w = c; edge[Index].next = pre[a]; pre[a] = Index++; swap(a,b); for(flag=0,j=pre[a];j!=-1;j=edge[j].next) { if(edge[j].v == b) { if(edge[j].w > c) { edge[j].w = c; } break; } } edge[Index].v = b; edge[Index].w = c; edge[Index].next = pre[a]; pre[a] = Index++; } } int bellman_ford() { int i,j,k; fill(dirs,dirs+point_maxn,lmaxn); int start = 1; int end = n; dirs[start] = 0; for(i=0;i<n-1;i++) { for(j=1;j<=n;j++) { for(k=pre[j];k!=-1;k=edge[k].next) { int s = j; int e = edge[k].v; if(dirs[e] > dirs[s] + edge[k].w) { dirs[e] = dirs[s] + edge[k].w; } } } } for(j=1;j<=n;j++) { for(k=pre[j];k!=-1;k=edge[k].next) { int s = j; int e= edge[k].v; if(dirs[e] > dirs[s] + edge[k].w) { return 0; } } } return 1; } void print() { if(!bellman_ford()) { printf("-1/n"); } else { printf("%d/n",dirs[n]); } } int main() { while(scanf("%d%d",&n,&m)!=EOF && (n!=0 || m!=0)) { Init(); print(); } return 0; }