单源最短路径Bellman-Ford算法 （转自dutor）

Dijkstra算法是处理单源最短路径的有效算法，但它局限于边的权值非负的情况，若图中出现权值为负的边，Dijkstra算法就会失效，求出的最短路径就可能是错的。这时候，就需要使用其他的算法来求解最短路径，Bellman-Ford算法就是其中最常用的一个。该算法由美国数学家理查德•贝尔曼（Richard Bellman, 动态规划的提出者）和小莱斯特•福特（Lester Ford）发明。Bellman-Ford算法的流程如下：
　　给定图G(V, E)（其中V、E分别为图G的顶点集与边集），源点s，

1. 数组Distant[i]记录从源点s到顶点i的路径长度，初始化数组Distant[n]为, Distant[s]为0；
2. 以下操作循环执行至多n-1次，n为顶点数：
   • 对于每一条边e(u, v)，如果Distant[u] + w(u, v) < Distant[v]，则另Distant[v] = Distant[u]+w(u, v)。w(u, v)为边e(u,v)的权值；
   • 若上述操作没有对Distant进行更新，说明最短路径已经查找完毕，或者部分点不可达，跳出循环。否则执行下次循环；
3. 为了检测图中是否存在负环路，即权值之和小于0的环路。对于每一条边e(u, v)，如果存在Distant[u] + w(u, v) < Distant[v]的边，则图中存在负环路，即是说改图无法求出单源最短路径。否则数组Distant[n]中记录的就是源点s到各顶点的最短路径长度。

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

 

Bellman-Ford算法C++实现

 1 const int MAXINT = 0xFFFF; //~ 不可达的路径长度上限
 2 struct Node
 3 {
 4     Node(): w(MAXINT){}
 5     int src, //~ 最短路径上的上一个顶点
 6         w; //~ 到该节点的路径长度
 7 };
 8 struct Edge
 9 {
10     Edge(){}
11     Edge(int f, int t): from(f), to(t){}
12     int from,
13         to;
14 };
15 int
16 main(int argc, char **argv)
17 {
18     vector<vector<int> > Adj;
19     int n, // 顶点数
20         m, //~ 边数
21         from,
22         to,
23         w,
24         start; //~ 源点
25     cin>>n;
26     vector<Node> Dist(n);
27     for(int i = 0; i < n; ++i)
28     {
29         Adj.push_back(vector<int>(n, MAXINT));
30         Adj[i][i] = 0;
31     }
32     cin>>m;
33     vector<Edge> Edges;
34     for(int i = 0; i < m; ++i)
35     {
36         cin>>from>>to>>w;
37         Adj[from][to] = w;
38         Edges.push_back(Edge(from, to));
39     }
40     cin>>start; //~ 从顶点start开始的最短路径
41     Dist[start].w = 0; //~
42     bool flag = true;
43     for( int i = 0; i < n - 1; ++i)
44     {
45         for(int j = 0; j < Edges.size(); ++j)
46         {
47             from = Edges[j].from;
48             to = Edges[j].to;
49             if(Dist[from].w == MAXINT || Adj[from][to] == MAXINT)
50                 continue;
51             if(Dist[from].w + Adj[from][to] < Dist[to].w)
52             {
53                 Dist[to].w = Dist[from].w + Adj[from][to];
54                 Dist[to].src = from;
55                 flag = false;
56             }
57         }
58         if(flag == true)
59             break;
60         else
61             flag = true;
62     }
63     //~ 检测有无负环路
64     for(int j = 0; j < Edges.size(); ++j)
65     {
66         from = Edges[j].from;
67         to = Edges[j].to;
68         if(Dist[from].w == MAXINT || Adj[from][to] == MAXINT)
69             continue;
70         if(Dist[from].w + Adj[from][to] < Dist[to].w)
71         {
72             cout<<"Negative Length Cycle Detected!"<<endl;
73             return 1;
74         }
75     }
76     //~ 下面代码供测试用
77     while(cin>>to)
78     {
79         int rp = to;
80         cout<<Dist[to].w<<" ";
81         while(rp != start) //~ 反向输出路径
82         {
83             cout<<rp<<" <- ";
84             if(Dist[to].w == MAXINT) break;
85             rp = Dist[rp].src;
86         }
87         cout<<start<<endl;
88     }
89     return 0;
90 }