最短路问题之Bellman-ford算法

题目：

　　最短路：给定两个顶点，在以这两个点为起点和终点的路径中，边的权值和最小的路径。考虑权值为点之间的距离。

　　单源最短路问题，Bellman-ford算法

　　思路：每次循环检查所有边，可优化。

　　应用于旅游等路径最小问题。

代码：

 import java.util.Arrays;

 public class 图的最短路问题_单源 {
     public static void main(String[] args) {
         int[] shortestPath = shortestPath(0);
         System.out.println(Arrays.toString(shortestPath));
         // 输出[0, 2, 5, 7, 11, 8, 16]
     }

     /**
      * 求起点到各顶点的最短距离
      *
      * @param s 起点
      * @return
      */
     private static int[] shortestPath(int s) {
         int n = graph.length;
         // 记录s到各顶点的最短距离
         int[] d = new int[n];
         for (int i = 0; i < n; i++) {
             d[i] = Integer.MAX_VALUE;
         }
         d[s] = 0;// 到自己的距离为0
         while (true) {
             boolean update = false;
             // 扫描所有的边
             for (int i = 0; i < n; i++) {
                 // 起点到i的最短距离还没算出来
                 if (d[i] == Integer.MAX_VALUE)
                     continue;
                 for (int j = 0; j < n; j++) {
                     int cost = graph[i][j]; // i,j之间的距离
                     if (cost > 0) { // i,j 两点之间有边，起点是i
                         if (d[j] > d[i] + cost) { // 起点先到i，i->j
                                                     // 两端距离加起来比起点直接到j的距离短，则更新
                             update = true;
                             d[j] = d[i] + cost;
                         }
                     }
                 }
             }
             // 无需任何更新，退出外循环
             if (!update)
                 break;
         }
         return d;
     }

     static int[][] graph = {
             { 0, 2, 5, 0, 0, 0, 0 },
             { 2, 0, 4, 6, 10, 0, 0 },
             { 5, 4, 0, 2, 0, 0, 0 },
             { 0, 6, 2, 0, 0, 1, 0 },
             { 0, 10, 0, 0, 0, 3, 5 },
             { 0, 0, 0, 1, 3, 0, 9 },
             { 0, 0, 0, 0, 5, 9, 0 }
             };
 }

　 对于上一个代码。可以先把边集提取出来，这样不用每次扫描二维数组。

　  Edge类：

 /**
  * 边 的封装
  * 边集可以用来表示图
  */
 public class Edge<T> implements Comparable<Edge>  {
     private T start;
       private T end;
       private int distance;

       public Edge(T start, T end, int distance) {
         this.start = start;
         this.end = end;
         this.distance = distance;
       }

       public T getStart() {
         return start;
       }

       public void setStart(T start) {
         this.start = start;
       }

       public T getEnd() {
         return end;
       }

       public void setEnd(T end) {
         this.end = end;
       }

       public int getDistance() {
         return distance;
       }

       public void setDistance(int distance) {
         this.distance = distance;
       }

       @Override
       public String toString() {
         return start + "->" + end + ":" + distance;
       }

       @Override
       public int compareTo(Edge obj) {
         int targetDis = obj.getDistance();
         return distance > targetDis ? 1 : (distance == targetDis ? 0 : -1);
       }
 }

　　优化过后的代码：

 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;

 public class 图的最短路问题_优化_边集 {
     public static void main(String[] args) {
         edges = buildEdges(graph);
         int[] shortestPath = shortestPath(0);
         System.out.println(Arrays.toString(shortestPath));
         // 输出[0, 2, 5, 7, 11, 8, 16]
     }

     /**
      * 求起点到各顶点的最短距离
      *
      * @param s
      *            起点
      * @return
      */
     private static int[] shortestPath(int s) {
         int n = graph.length;
         // 记录s到各顶点的最短距离
         int[] d = new int[n];
         for (int i = 0; i < n; i++) {
             d[i] = Integer.MAX_VALUE;
         }
         d[s] = 0;// 到自己的距离为0
         while (true) {
             boolean update = false;

             for (Edge<Integer> e : edges) {
                 if (d[e.getStart()] != Integer.MAX_VALUE && d[e.getEnd()] > d[e.getStart()] + e.getDistance()) {
                     update = true;
                     d[e.getEnd()] = d[e.getStart()] + e.getDistance();
                 }
             }

             if (!update)
                 break;
         }
         return d;
     }

     static List<Edge<Integer>> edges;

     static List<Edge<Integer>> buildEdges(int[][] graph) {
         int n = graph.length;
         List<Edge<Integer>> edges = new ArrayList<>();
         for (int i = 0; i < n; i++) {
             for (int j = 0; j < n; j++) {
                 int cost = graph[i][j]; // i,j之间的距离
                 if (cost > 0) { // i,j 两点之间有边，起点是i
                     edges.add(new Edge<>(i, j, cost));
                 }
             }
         }
         return edges;
     }

     static int[][] graph = {
             { 0, 2, 5, 0, 0, 0, 0 },
             { 2, 0, 4, 6, 10, 0, 0 },
             { 5, 4, 0, 2, 0, 0, 0 },
             { 0, 6, 2, 0, 0, 1, 0 },
             { 0, 10, 0, 0, 0, 3, 5 },
             { 0, 0, 0, 1, 3, 0, 9 },
             { 0, 0, 0, 0, 5, 9, 0 }
             };
 }