http://blog.csdn.net/niushuai666/article/details/6791765

Dijkstra演算法是處理單源最短路徑的有效演算法，但它侷限於邊的權值非負的情況，若圖中出現權值為負的邊，Dijkstra演算法就會失效，求出的最短路徑就可能是錯的。

這時候，就需要使用其他的演算法來求解最短路徑，Bellman-Ford演算法就是其中最常用的一個。該演算法由美國數學家理查德•貝爾曼（Richard Bellman, 動態規劃的提出者）和小萊斯特•福特（Lester Ford）發明。

適用條件&範圍：

單源最短路徑(從源點s到其它所有頂點v);

有向圖&

邊權可正可負(如有負權迴路輸出錯誤提示);

差分約束系統;

Bellman-Ford演算法的流程如下：
給定圖G(V, E)（其中V、E分別為圖G的頂點集與邊集），源點s，陣列Distant[i]記錄從源點s到頂點i的路徑長度，初始化陣列Distant[n]為, Distant[s]為0；

以下操作迴圈執行至多n-1次，n為頂點數：
對於每一條邊e(u, v)，如果Distant[u] + w(u, v) < Distant[v]，則另Distant[v] = Distant[u]+w(u, v)。w(u, v)

為了檢測圖中是否存在負環路，即權值之和小於0的環路。對於每一條邊e(u, v)，如果存在Distant[u] + w(u, v) < Distant[v]的邊，則圖中存在負環路，即是說改圖無法求出單源最短路徑。否則陣列Distant[n]中記錄的就是源點s到各頂點的最短路徑長度。

可知，Bellman-Ford演算法尋找單源最短路徑的時間複雜度為O(V*E).

Bellman－Ford演算法可以大致分為三個部分
第一，初始化所有點。每一個點儲存一個值，表示從原點到達這個點的距離，將原點的值設為0

測試程式碼如下：（下面為有向圖的Bellman-Ford演算法。。。。。）

#include<iostream>  
#include<cstdio>  
using namespace std;  
  
#define MAX 0x3f3f3f3f  
#define N 1010  
int nodenum, edgenum, original; //點，邊，起點  
  
typedef struct Edge //邊  
{  
    int u, v;  
    int cost;  
}Edge;  
  
Edge edge[N];  
int dis[N], pre[N];  
  
bool Bellman_Ford()  
{  
    for(int i = 1; i <= nodenum; ++i) //初始化  
        dis[i] = (i == original ? 0 : MAX);  
    for(int i = 1; i <= nodenum - 1; ++i)  
        for(int j = 1; j <= edgenum; ++j)  
            if(dis[edge[j].v] > dis[edge[j].u] + edge[j].cost) //鬆弛（順序一定不能反~）  
            {  
                dis[edge[j].v] = dis[edge[j].u] + edge[j].cost;  
                pre[edge[j].v] = edge[j].u;  
            }  
            bool flag = 1; //判斷是否含有負權迴路  
            for(int i = 1; i <= edgenum; ++i)  
                if(dis[edge[i].v] > dis[edge[i].u] + edge[i].cost)  
                {  
                    flag = 0;  
                    break;  
                }  
                return flag;  
}  
  
void print_path(int root) //列印最短路的路徑（反向）  
{  
    while(root != pre[root]) //前驅  
    {  
        printf("%d-->", root);  
        root = pre[root];  
    }  
    if(root == pre[root])  
        printf("%d\n", root);  
}  
  
int main()  
{  
    scanf("%d%d%d", &nodenum, &edgenum, &original);  
    pre[original] = original;  
    for(int i = 1; i <= edgenum; ++i)  
    {  
        scanf("%d%d%d", &edge[i].u, &edge[i].v, &edge[i].cost);  
    }  
    if(Bellman_Ford())  
        for(int i = 1; i <= nodenum; ++i) //每個點最短路  
        {  
            printf("%d\n", dis[i]);  
            printf("Path:");  
            print_path(i);  
        }  
    else  
        printf("have negative circle\n");  
    return 0;  
}  

4 6 1
1 2 20
1 3 5
4 1 -200
2 4 4
4 2 4
3 4 2

和：

4 6 1
1 2 2
1 3 5
4 1 10
2 4 4
4 2 4
3 4 2