货郎担问题（TSP问题）

货郎担问题也叫旅行商问题，即TSP问题（Traveling Salesman Problem），是数学领域中著名问题之一。

有n个城市，用1，2，…，n表示，城i,j之间的距离为dij，有一个货郎从城1出发到其他城市一次且仅一次，最后回到城市1，怎样选择行走路线使总路程最短？

货郎担问题要从图g的所有周游路线中求取具有最小成本的周游路线，而由始点出发的周游路线一共有（n一1）！条，即等于除始结点外的n一1个结点的排列数，因此货郎担问题是一个排列问题。通过枚举（n一1）！条周游路线，从中找出一条具有最小成本的周游路线的算法，其计算时间显然为o(n！）。

解货郎担问题：核心是动态规划，自底向上的思想。

下面是代码：我还没写出来……

哼哼：弄出来了

 public class Main {

     private static int N = 6;          //此例中共有6个点
     private static int index = 1;      //货郎担问题 解的时候假定了第一个起始点就是0，所以从1开始
     private int x[] = new int[N];      //每个x[index] 存放的是位置为index 的点  比如index=0  x[1] = 2  位于位置1的点是 点2
     private static int bestX[] = new int[N];    //最优路径
     private int cLength = 0;                     //当前已经加入的点的长度
     private static int allLength = Integer.MAX_VALUE;    //总长
     private int weight[][] ={ {0,2,8,5,1,8},
                                 {3,0,1,8,5,2},
                                 {6,2,0,3,6,1},
                                 {88,3,6,0,6,4},
                                 {7,2,6,1,0,5},
                                 {6,3,9,1,4,0}};

     public static void main(String[] args) {
         Main tsp = new Main();
         tsp.getTSP(index);
         System.out.println(allLength);
         for (int i = 0; i < N; i++) {
             System.out.print(bestX[i]+"  ");
         }
     }
     private boolean ifExist(int index){                      //判断index这个位置上是否可以放x[index] 这个点
         int i=0;                                               //已经加入的位置  x[i]才是该位置的点
         while(i<index){
             if(x[i]==x[index]){                                //判断当前位置的点是否已经出现了
                 return false;
             }
             i++;
         }
         return true;
     }

     private void getTSP(int index){
         if(index==N-1){
             for(int j=1;j<=N;j++) {
                 x[index] = Math.floorMod(x[index] + 1, N);         //通过取余弄出一个当前位置的点
                 if (ifExist(index) && cLength + weight[x[index - 1]][x[index]] + weight[x[index]][x[0]]< allLength) {    //总长= 已加入长度+ 到该点+该点到初始
                     allLength = cLength + weight[x[index - 1]][x[index]]+weight[x[index]][x[0]];
                     for (int i = 0; i < N; i++) {
                         bestX[i] = x[i];
                     }
                 }
             }
         }else {
             for (int j = 1; j <= N; j++) {
                 x[index] = Math.floorMod(x[index] + 1, N);  //给定当前这个位置的点的值
                 if (ifExist(index) && cLength + weight[x[index - 1]][x[index]] < allLength) {
                     cLength += weight[x[index - 1]][x[index]];
                     getTSP(index + 1);
                     cLength -= weight[x[index - 1]][x[index]];
                 }
             }
         }
     }

 }

这是结果：