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

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

適用條件&範圍：

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

有向圖&無向圖(無向圖可以看作(u,v),(v,u)同屬於邊集E的有向圖);

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

差分約束系統;

Bellman-Ford演算法的虛擬碼如下：
  BELLMAN-FORD(G,w，s）

   Initialize-single-sourse（G，s）//初始化原點d[s]=0,其餘所有頂點d[v]=無窮大，pi[v]=NIL

  for i=1 to | V[G] |-1

     for each edge (u,v)屬於E[G]

             do RELAX(u,v,w)  //   O(V*E) 次鬆弛後，d[v] 為最短路徑值

  for each edge (u,v)屬於E[G]

    if  d[v]>d[u]+w(u,v)        //對所有邊，若 d[v]>d[u]+w(u,v) ，則 d[v] 不是最短，存在可達的負權迴路

         then return FALSE

 return TRUE

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

Bellman－Ford演算法可以大致分為三個部分
第一，初始化所有點。每一個點儲存一個值，表示從原點到達這個點的距離，將原點的值設為0，其它的點的值設為無窮大（表示不可達）。
第二，進行迴圈，迴圈下標為從1到n－1（n等於圖中點的個數）。在迴圈內部，遍歷所有的邊，進行鬆弛計算。
第三，遍歷途中所有的邊（edge（u，v）），判斷是否存在這樣情況：
d（v） > d (u) + w(u,v)
則返回false，表示途中存在從源點可達的權為負的迴路。

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

1. #include<iostream>
2. #include<cstdio>
3. usingnamespace std;  
4. #define MAX 0x3f3f3f3f
5. #define N 1010
6. int nodenum, edgenum, original; //點，邊，起點
7. typedefstruct Edge //邊
8. {  
9.     int u, v;  
10.     int cost;  
11. }Edge;  
12. Edge edge[N];  
13. int dis[N], pre[N];  
14. bool Bellman_Ford()  
15. {  
16.     for(int i = 1; i <= nodenum; ++i) //初始化
17.         dis[i] = (i == original ? 0 : MAX);  
18.     for(int i = 1; i <= nodenum - 1; ++i)  
19.         for(int j = 1; j <= edgenum; ++j)  
20.             if(dis[edge[j].v] > dis[edge[j].u] + edge[j].cost) //鬆弛（順序一定不能反~）
21.             {  
22.                 dis[edge[j].v] = dis[edge[j].u] + edge[j].cost;  
23.                 pre[edge[j].v] = edge[j].u;  
24.             }  
25.             bool flag = 1; //判斷是否含有負權迴路
26.             for(int i = 1; i <= edgenum; ++i)  
27.                 if(dis[edge[i].v] > dis[edge[i].u] + edge[i].cost)  
28.                 {  
29.                     flag = 0;  
30.                     break;  
31.                 }  
32.                 return flag;  
33. }  
34. void print_path(int root) //列印最短路的路徑（反向）
35. {  
36.     while(root != pre[root]) //前驅
37.     {  
38.         printf("%d-->", root);  
39.         root = pre[root];  
40.     }  
41.     if(root == pre[root])  
42.         printf("%d\n", root);  
43. }  
44. int main()  
45. {  
46.     scanf("%d%d%d", &nodenum, &edgenum, &original);  
47.     pre[original] = original;  
48.     for(int i = 1; i <= edgenum; ++i)  
49.     {  
50.         scanf("%d%d%d", &edge[i].u, &edge[i].v, &edge[i].cost);  
51.     }  
52.     if(Bellman_Ford())  
53.         for(int i = 1; i <= nodenum; ++i) //每個點最短路
54.         {  
55.             printf("%d\n", dis[i]);  
56.             printf("Path:");  
57.             print_path(i);  
58.         }  
59.     else
60.         printf("have negative circle\n");  
61.     return 0;  
62. }