概述

Bellman Ford算法可以用来解决加权图中的最短路径问题。其与Dijkstra算法的区别在于Belllman Ford算法的应用范围更广，例如其可以用来处理带有负权重的加权图中的最短路径问题。由于Dijkstra算法本质上是一种贪心算法，因而当图中存在路径权值之和为负的环时，Dijkstra算法会给出错误的结果因为其总是偏向于选择当前情况下的局部最优路径。Bellman Ford算法的时间复杂度高于Dijkstra算法。

历史

Bellman Ford算法最初于1955年被Alfonso Shimbel提出，但最终基于1958和1956年发表论文的 Richard Bellman和Lester Ford, Jr.二人命名。Edward F. Moore于1957年也提出了该算法，因此该算法有时也称作是Bellman Ford Moore算法。

负权重带环图的问题

包含负权重的图在不少实际问题中有所应用。例如在寻找化学反应链中需要最少能量的路径中，该反应链可能既包含吸热反应也包含放热反应，那么我们可以认为放热反应是负权重路径而吸热反应是正权重路径。在包含负权重带环图的问题中，从起始点开始的一条路径如果能够到达一个整体权重之和为负的环，则最短路径在中情况下将不存在，因为这一路径总可以通过在负权重路径中循环来不断降低总权重。而使用Bellman Ford算法则能够发现这一问题。

算法描述

简单来说，类似于Dijkstra算法，Bellman Ford算法首先将从源结点到达剩余所有结点的距离初始化为无穷大，而从源结点到其本身的距离则初始化为0。然后算法将循环检查图中的每一条边。如果这条边能够缩短从源结点到某一目的结点的距离，则新的最短距离将被记录下来。具体来说，对于一条边u -> v，设其权重为weight(u, v)，而结点u，v距离源结点src的距离分别为dist[u]，dist[v]。则dist[v] = min(dist[v], dist[u] + weight(u,v)。在每一次循环中该算法都检查所有的边。对于第i次循环，算法将得到从源结点出发不超过i步能够到达的结点的最短距离（在某些情况下也可能多于i）。因为对于N个结点的图来说，不包含环的最短距离最长为N-1，所以该算法需要循环检查所有边N-1次。

在循环结束后，算法将再多循环检查一遍所有的边并尝试更新最短路径。如果从源结点出发到某一点的最短距离在这一次循环中能够被更新，则说明在这一路径上至少存在一个权重之和为负的环。

算法的Java实现

public class BellmanFord {
    /**
     * Find the shortest path from src to all other nodes in the graph 
     * represented using an array of arrays of shape [u, v, weight],
     * in which u and v are the start and end point of the edge, respectively.
     * @param  n     Number of nodes in the graph.
     * @return       An array containing the shortest path from src to all other 
     * nodes in the graph, with the predecessor of the nodes. For each node i, the
     * array contains a two-tuple [distance, predecessor]. 
     * If a shortest path from src to node does not exist, distance and predecessor will
     * both be Integer.MAX_VALUE.
     */
    public int[][] findShortestPath(int src, int n, int[][] edges) {
        // first step, initialize the distance
        int[] dist = new int[n];
        int[] pre = new int[n];
        int INF = Integer.MAX_VALUE / 2;
        Arrays.fill(dist, INF);
        dist[src] = 0;
        Arrays.fill(pre, Integer.MAX_VALUE);

        // second step, compute shortest path with at most n-1 steps
        for (int i = 1; i < n; i++) {
            for (int[] edge : edges) {
                int u = edge[0], v = edge[1], weight = edge[2];
                if (dist[v] > dist[u] + weight) {
                    pre[v] = u;
                }
                dist[v] = Math.min(dist[v], dist[u] + weight);
            }
        }

        // third step, check the existance of negative weight cycle
        for (int[] edge : edges) {
            int u = edge[0], v = edge[1], weight = edge[2];
            if (dist[u] < INF && dist[u] + weight < dist[v]) {
                System.out.println("Graph contains negative weight cycle");
            }
        }

        int[][] ret = new int[n][2];
        for (int i = 0; i < n; i++) {
            ret[i] = new int[]{dist[i] == INF ? Integer.MAX_VALUE : dist[i], pre[i]};
        }

        return ret;
    }
}

时间复杂度

从上面代码中我们可以看出我们在每一次循环中都会检查所有的边，共计循环了N次，那么算法的时间复杂度为O(N * E)，其中N为图中的结点总数，E为图中的边的数目。

空间复杂度

O(N)。因为我们使用了O(N)大小的数组来存储最短路径的距离。

潜在优化

对于step 2，如果在某一次循环中我们没有更新任何最短距离，则这一循环可以提前结束。因为这证明该算法已经找到了从源结点出发能够到达的所有结点的最短路径。这一优化使得step 2的循环次数能够少于O(N-1)。