有向图单源非负权值回路最短路径——BellmanFord算法

BellmanFord算法是一种暴力求解算法O(N3)，它考虑所有情况，所以可以允许边的权值为负。（不过不允许出现负权值回路，因为那样会出现无限小）

之所以说它暴力，是因为它求出了每个节点所有长度为1的路径，再求所有长度为2的路径，并更新最短路径数组dist[]和path[]，如此迭代直至求到长度n-1的路径。（n为图节点个数）

整体来看，每个节点纵向比较，从1到n-1长度的路径中取最小值作为最终路径长度。

因为它考虑了所有情况，所以负边也可以算出。

因为暴力，复杂度比Dijkstra高一个数量级，达到了O(N3)。不过Dijkstra不能计算负边，所以倒也划算。

下面给出算法。

  public int minPathBF(int source, int target){
        if (source == target){
            System.out.println("(" + source + " " + target + ")");
            return 0;
        }
        int[] path = bellmanFord(source);
        int result = 0;
        String way = "";
        while (-1 != path[target]){
            way = "(" + path[target] + " " + target + ") " + way;
            result += graph[path[target]][target];
            target = path[target];
        }
        System.out.println(way);
        return result;
    }

    private int[] bellmanFord(int vertex){
        int[] path = new int[numVertices];
        int[] dist = new int[numVertices];
        //initial
        for (int i = 0; i < numVertices; i++) {
            if (graph[vertex][i] != 0 && graph[vertex][i] < 1000){
                dist[i] = graph[vertex][i];
                path[i] = vertex;
            }else {
                dist[i] = 1000;
                path[i] = -1;
            }
        }
        for (int i = 2; i < numVertices; i++){// calculate to n-1 path length
            for (int j = 0; j < numVertices; j++){// calculate num j vertex path
                if (j != vertex){
                    for (int k = 0; k < numVertices; k++) {
                        if (k != vertex && graph[k][j] != 0 && graph[k][j] < 1000 && dist[k] < 1000){
                            if (graph[k][j] + dist[k] < dist[j]){
                                dist[j] = dist[k] + graph[k][j];
                                path[j] = k;
                            }
                        }
                    }
                }
            }
        }
        return path;
    }