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

 1   public int minPathBF(int source, int target){
 2         if (source == target){
 3             System.out.println("(" + source + " " + target + ")");
 4             return 0;
 5         }
 6         int[] path = bellmanFord(source);
 7         int result = 0;
 8         String way = "";
 9         while (-1 != path[target]){
10             way = "(" + path[target] + " " + target + ") " + way;
11             result += graph[path[target]][target];
12             target = path[target];
13         }
14         System.out.println(way);
15         return result;
16     }
17 
18     private int[] bellmanFord(int vertex){
19         int[] path = new int[numVertices];
20         int[] dist = new int[numVertices];
21         //initial
22         for (int i = 0; i < numVertices; i++) {
23             if (graph[vertex][i] != 0 && graph[vertex][i] < 1000){
24                 dist[i] = graph[vertex][i];
25                 path[i] = vertex;
26             }else {
27                 dist[i] = 1000;
28                 path[i] = -1;
29             }
30         }
31         for (int i = 2; i < numVertices; i++){// calculate to n-1 path length
32             for (int j = 0; j < numVertices; j++){// calculate num j vertex path
33                 if (j != vertex){
34                     for (int k = 0; k < numVertices; k++) {
35                         if (k != vertex && graph[k][j] != 0 && graph[k][j] < 1000 && dist[k] < 1000){
36                             if (graph[k][j] + dist[k] < dist[j]){
37                                 dist[j] = dist[k] + graph[k][j];
38                                 path[j] = k;
39                             }
40                         }
41                     }
42                 }
43             }
44         }
45         return path;
46     }