Dijkstra 算法虽然好，但是他不能解决带有负权边的（边的权值为负数）的图，下面我们就来说一下几乎完妹求最短路径的算法Bellman-ford。Bellman-ford算法也非常简单，核心代码只有几行，并且可以完美的解决带有负权的图，先来看看这个核心代码吧

for(int k = 1 ; k <= n - 1 ; k ++)
{
    for(int i = 1 ; i < m ; i ++)
    {
        if(dis[v[i]] > dis[u[i]] + w[i])
            dis[v[i]] = dis[u[i]] + w[i] ;
    }
}

上边的代码外循环共循环了n – 1 次（n为顶点的个数），内循环共循环了m次（m代表边的个数）即枚举每一条边， dis 数组是的作用和dijkstra 算法一样，也是用来记录源点到其余各个顶点的最短路径，u，v，w 三个数组用来记录边的信息。例如第i条边存储在u[i]、v[i]、w[i]中，表示从顶点u[i]到顶点v[i]这条边（u[i] –> v[i]）权值为w[i]。

两层for循环的意思是：看看能否通过u[i]—>v[i] （权值为w[i]）这条边，使的1号顶点的距离变短。即1号顶点到u[i]号顶点的距离（dis[u[i]]） 加上 u[i] —> v[i]这条边（权值为w[i]）的值是否比原来1号顶点到v[i]号距离（dis[v[i]]）要小。这点感觉和迪杰斯特拉的松弛操作有点儿像。。。

我们把每一条边都松弛一遍后会怎么样呢？我们来举个例子，求下图1号顶点到其余所有顶点的最短路径。

我们还是用一个dis数组来存储1号顶点到所有顶点的距离。

我们先来初始化：

上方右图中每个顶点旁的值为该定点的最短路的“估计值”（当前1号顶点到他的距离），即dis中对应的值。根据边给出的顺序，先来处理一下第一条边“2-3-2”（2–2–>3通过这条边进行松弛）即判断dis[3]是否大于dis[2]+2。此时的dis[3]是∞，dis[2]的值也是∞，因此dis[2] + 2也是∞，所以这条边松弛失败。

同时我们继续处理第二条边“1–2 —       -3” （1–“-3”–>2 ） 我们发现dis[2] > dis[1] + (-3) ，通过这条边可以使dis[2]的值从∞变为 -3 ，所以这个点松弛成功。我们可以用同样的方法来处理剩下的一条边，对所有的边进行一遍松弛操作后的结果如下。

我们能发现，在对每一条边都进行一次松弛操作后，已经使dis[2]和dis[5]的值变小，即1号顶点到2号顶点和1号顶点到5号顶点的距离都变短了。

接下来我们要对所有边再进行一轮松弛操作，操作过程大致和上边的一样，再看看会有什么变化。

      在这一-轮松弛时，我们发现，现在通过“2 3 2”(2→3)这条边，可以使1号顶点到3号顶点的距离(dis[3]) 变短了。爱思考的同学就会问了，这条边在上一一轮也松弛过啊，为什么上一一轮松弛失败了，这一”轮却成功了呢?因为在第一 轮松弛过后，1号顶点到2号顶点的距离(dis[2]) 已经发生了变化，这一-轮再通过“232”(2-→3)这条边进行松弛的时候，已经可以使1号顶点到3号顶点的距离(dis[3]) 的值变小。     换句话说，第1轮在对所有的边进行松弛之后，得到的是从1号顶点“只能经过一条边”到达其余各顶点的最短路径长度。第2轮在对所有的边进行松弛之后，得到的是从1号顶点“最多经过两条边”到达其余各顶点的最短路径长度。如果进行k轮的话，得到的就是1号顶点“最多经过k条边”到达其余各顶点的最短路径长度。现在又有一一个新问题:需要进行多少轮呢?

    只要进行n – 1 轮就可以了，因为在一个含有n个顶点的图中，任意两点之间的最短路径最多包含n-1条边。

   我们这个算法真的就只能包含n-1条边吗？最短路径中不能包含回路吗？    答案是:不可能!最短路径肯定是一个不包含回路的简单路径。回路分为正权回路(即回路权值之和为正)和负权回路(即回路权值之和为负)。我们分别来讨论一下为什么这两种回路都不可能有。如果最短路径中包含正权回路，那么去掉这个回路，一定可以得到更短的路径。如果最短路径中包含负权回路，那么肯定没有最短路径，因为每多走一次 负权回路就可以得到更短的路径。  因此，最短路径肯定是-一个不包含回路的简单路径，即最多包含n-1条边，所以进行n-1轮松弛就可以了。

  扯了半天，回到之前的例子，继续进行第3轮和第4轮松弛操作，这里只需进行4轮就可以了，因为这个图一共只有5个顶点。

这里看似貌似不需要第四轮，因为执行完第四轮没有任何变化！没错，其实就是最多进行  n – 1 轮松弛。

整个算法用一句话概括就是：对所有的边进行n-1次松弛操作。核心代码就只有几行，如下：

for(int k = 1 ; k <= n - 1 ; k ++) //进行n-1轮松弛
{
    for(int i = 1 ; i < m ; i ++)  // 枚举每一条边
    {
        if(dis[v[i]] > dis[u[i]] + w[i])  //尝试对每一条边松弛
            dis[v[i]] = dis[u[i]] + w[i] ;
    }
}

   我们来总结一下。因为最短路径上最多有n-1条边，所以Bellman-Ford算法最多有n-1个阶段。在每-一个阶段，我们对每一条边 都要执行松弛操作。其实每实施一次松弛操作， 就会有一些顶点已经求得其最短路，即这些顶点的最短路的“估计值”变为“确定值”。此后这些顶点的最短路的值就会一直保持不变，不再受后续松弛操作的影响(但是，每次还是会判断是否需要松弛，这里浪费了时间，是否可以优化呢? )。在前k个阶段结束后，就已经找出了从源点发出“最多经过k条边”到达各个顶点的最短路。直到进行完n-1个阶段后，便得出了最多经过n-1条边的最短路。

  Bellman-Ford算法的完整的代码如下。

#include<bits/stdc++.h>
const int INF = 99999999;
using namespace std;
int main()
{
    int u[100] , v[100] , w[100] , dis[100] , n , m ;
    cin>>n>>m;
    for(int i = 1 ; i <= m ; i ++)
    {
        cin>>u[i] >> v[i] >> w[i];
    }
    for(int i = 1 ; i  <= n ; i ++)
    dis[i] = INF;
    dis[1] = 0;
    for(int k = 1 ; k <= n - 1 ; k ++)
        for(int i = 1 ; i <= m ; i ++)
            if(dis[v[i]] > dis[u[i]] + w[i])
                dis[v[i]] = dis[u[i]] + w[i];
            for(int i = 1 ; i <= n ; i ++)
                cout<<dis[i]<<" ";
    return 0 ;
}


/*
5 5
2 3 2
1 2 -3
1 5 5
4 5 2
3 4 3
*/

除此之外，bellman-ford 算法还可以检测出一个图是否含有负权回路。如果进行n-1轮松弛操作之后仍然存在

if(dis[v[i]] > dis[u[i]] + w[i])

                dis[v[i]] = dis[u[i]] + w[i];

的情况，也就是说在进行n-1轮松弛后，仍可以继续成功松弛，那么此图必然存在负权回路。如果一个图没有负权回路，那么最短路径所包含的边最多为n-1条，即进行n-1轮松弛操作后最短路不会再发生变化。如果在n-1轮松弛后最短路仍然可以 发生变化，则这个图一定有负权回路，管不见代码如下：

 for(int k = 1 ; k <= n - 1 ; k ++)
        for(int i = 1 ; i <= m ; i ++)
            if(dis[v[i]] > dis[u[i]] + w[i])
                dis[v[i]] = dis[u[i]] + w[i];
                //检测负权回路
                flag = 0 ;
                for(int i = 1 ; i <= m ; i ++)
                if(dis[v[i]] > dis[u[i]] + w[i])
                    flag = 1 ;
                if(flag == 1)
                    printf("此图没有负权回路\n");

   显，Bellman-Ford 算法的时间复杂度是O(NM)，这个时间复杂度貌似比Dijkstra 算法还要高，我们还可以对其进行优化。在实际操作中，Bellman-Ford算法经常会在未达到n-1轮松弛前就已经计算出最短路，之前我们已经说过，n-1其实是最大值。因此可以添加一个一维数组用来备份数组dis。如果在新-一轮的松弛中数组dis没有发生变化，则可以提前跳出循环，代码如下。

#include<bits/stdc++.h>
const int INF = 9999999;
using namespace std;
int main()
{
    int u[100] , v[100] , w[100] , dis[100] , n , m , ck , flag;
    cin>>n>>m;
    for(int i = 1 ; i <= m ; i ++)
    {
        cin>>u[i] >> v[i] >> w[i];
    }
    for(int i = 1 ; i  <= n ; i ++)
    dis[i] = INF;
    dis[1] = 0;
    for(int k = 1 ; k <= n - 1 ; k ++)
    {
        ck = 0 ; //用来标记本轮松弛操作中数组dis是否会发生更新
        for(int i = 1 ; i <= m ; i ++)
        {
            if(dis[v[i]] > dis[u[i]] + w[i])
            {
                 dis[v[i]] = dis[u[i]] + w[i];
                 ck = 1 ;  //数组dis发生更新，改变check的值
            }
        }
        if(ck == 0)
            break;   //如果dis数组没有更新，提前退出循环结束算法
    }
    flag = 0 ;
    for(int i = 1 ; i <= m ; i ++)
    if(dis[v[i]] > dis[u[i]] + w[i])
                flag = 1;
                if(flag == 1)
                    printf("此图包含有负权回路\n");
                else
                {
                    for(int i = 1 ; i <= n ; i ++)
                        printf("%d ",dis[i]);
                }
    return 0 ;
}

/*
5 5
2 3 2
1 2 -3
1 5 5
4 5 2
3 4 3
*/

     Bellman-Ford算法的另外一种优化在文中已经有所提示:在每实施一次松弛操作后，就会有一些项点已经求得其最短路，此后这些顶点的最短路的估计值就会一直保持不变， 不再受后续松弛操作的影响，但是每次还要判断是否需要松弛，这里浪费了时间。这就启发我们:每次仅对最短路估计值发生变化了的顶点的所有出边执行松弛操作。

      美国应用数学家Richard Bellman (理查德。贝尔曼)于1958 年发表了该算法。此外Lester Ford, Jr在1956年也发表了该算法。因此这个算法叫做Bellman-Ford算法。其实EdwardF. Moore在1957年也发表了同样的算法，所以这个算法也称为Bellman-Ford-Moore算法。Edward F. Moore很熟悉对不对?就是那个在“如何从迷宫中寻找出路”问题中提出了广度优先搜索算法的那个家伙。

例题：
POJ1860、POJ2240、POJ3259